package com.desire.test;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author desire
 */
public class _34_stream流技术 {

    public static void main(String[] args) {
        // .distinct(1,4) 1 2 3 4
        IntStream is = IntStream.rangeClosed(1, 3);
        // 1*2=2 2*3=6  前两个计算的结果再与第三个数进行计算
        int i = is.reduce(1, (a, v) -> a * v);
        System.out.println(i);
        Stream<String> aa = Stream.of("mysql", "php", "java", "javascript");
        System.out.println(aa.reduce("", (a, b) -> a.concat(b)));

        // 阶乘
        var ii = IntStream.rangeClosed(1, 6);
        System.out.println(ii.reduce((a, b) -> a * b).getAsInt());
    }

    public static void main3(String[] args) {
        int[] ints = {1, 2, 4, 6, 8, 9, 3, 2, 6, 23};
        // 获取最小值
        System.out.println("最小值: " + Arrays.stream(ints).min().getAsInt());
        // 最大
        System.out.println("最大值: " + Arrays.stream(ints).max().getAsInt());
        // 计数
        System.out.println("计 数: " + Arrays.stream(ints).count());
        // 求和
        System.out.println("求 和: " + Arrays.stream(ints).sum());
        //平均值
        System.out.printf("平均值: %.2f%n", Arrays.stream(ints).average().getAsDouble());


        String str = "C:\\Users\\desire\\Desktop\\javaProject\\01-javaBase\\src\\main\\java\\com\\desire\\test";
        str.lines().filter(e -> e.startsWith("s"))
                .map(e -> String.format("hello: %s", e.toLowerCase()))
                .sorted(Comparator.comparingInt(String::length))
                .forEach(System.out::println);

        Stream<String> ss = Stream.of("java", "javascript", "mysql", "php", "python");
        ss.filter(e -> e.startsWith("java")).map(e -> String.format("hello: %s", e.toUpperCase())).forEach(System.out::println);

        // .distinct() 去重返回一个新的流
        System.out.println(Stream.of(1, 2, 3, 1, 6, 5, 1, 9, 10, 1, 22).distinct().count());
    }

    public static void main2(String[] args) {
        IntStream empty;
        empty = IntStream.of(12, 45, 45324, 12);
        empty = IntStream.of(1, 1);
        empty = IntStream.rangeClosed(1, 10);

        Random random = new Random();
        empty = IntStream.generate(() -> random.nextInt(20) + 1).limit(8).skip(2);

        Consumer ic = con -> System.out.printf("%d ", con);

        // 升序
        //empty.sorted().forEach(a -> System.out.printf("%d ", a));

        // 降序  需要先进行装箱boxed()
        //empty.boxed().sorted((a, b) -> b - a).forEach(ic);
        // empty.boxed().sorted(Comparator.reverseOrder()).forEach(ic);


        // 乱序  没有相应的乱序封装方法
        Stream<Integer> stream = Stream.of(12, 2, 345, 2, 56, 23, 2131, 23);
        stream.sorted((a, b) -> random.nextBoolean() ? 1 : -1).forEach(ic);
    }


    public static void main1(String[] args) {
        IntStream is = IntStream.of(10, 20, 34, 5, 6, 76);
        //is.forEach(System.out::println);

        // 1 到 100 的和
        //System.out.println(IntStream.rangeClosed(1, 100).sum());

        // 返回一个无限序列无序流，其中每个元素都是由提供的IntSupplier生成的。这适用于生成恒定流、随机元素流等。
        // 参数: s -生成元素的IntSupplier 返回: 一个新的无限顺序无序的IntStream
        //System.out.println(IntStream.generate(() -> 5).limit(3).count());

        // 定义一个流, 生成随机数, 限制只生成5个 然后遍历打印
        IntStream i2 = IntStream.generate(() -> {
            Random rand = new Random();
            return rand.nextInt(100) + 1;
        }).limit(10);

        // 消费者 用了就直接被清理掉
        IntConsumer ic = (a) -> System.out.printf("%d ", a);
        i2.forEach(ic);
        //  i2.forEach((a) -> System.out.printf("%d ", a)); 每传入一个数 就格式化输出
        System.out.println();

        // 13579
        IntStream.iterate(1, a -> a + 2).limit(5).forEach(ic);
        System.out.println();

        // 02468
        IntStream.iterate(0, a -> a + 2).limit(5).forEach(ic);
        System.out.println();

        // .skip() 丢弃流的前n个元素 (024丢弃)6 8 10 12 14 16 18 20 22 24 26 28 30 32 34
        IntStream.iterate(0, a -> a + 2).skip(3).limit(15).forEach(ic);
        System.out.println();

        // IntStream 转换为List<Integer>
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        list.add(1);
        list.forEach(System.out::println);

        System.out.println("***".repeat(20));

        // 返回一个IntStream，由对该流的元素应用给定函数的结果组成
        IntStream ii = list.stream().mapToInt(i -> i);
        ii.forEach(ic);

        // list集合转stream流
        List<String> li = List.of("java", "python");
        Stream<String> stream = li.stream();
        // Optional[java]   java
        System.out.println(stream.findFirst().get());

    }
}
